home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / networke / xfirepow.000 / xfirepow / xfirepower-0.84 / client / libsprite / makewindow.c < prev    next >
C/C++ Source or Header  |  1995-05-23  |  13KB  |  503 lines
  1. #include "allincludes.h"
  2.  
  3. #define tiny_width 3
  4. #define tiny_height 3
  5. #define tiny_x_hot 1
  6. #define tiny_y_hot 1
  7. static unsigned char tiny_bits[] = {
  8.   0x05, 0x02, 0x05, };
  9. static unsigned char tinymask_bits[] = {
  10.   0x05, 0x02, 0x05, };
  11.  
  12. #define cross_width 16
  13. #define cross_height 16
  14. #define cross_x_hot 7
  15. #define cross_y_hot 7
  16. static unsigned char cross_bits[] = {
  17.     0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xc0, 0x01, 0x80, 0x00,
  18.     0x10, 0x04, 0x3f, 0x7e, 0x10, 0x04, 0x80, 0x00, 0xc0, 0x01, 0x80, 0x00,
  19. 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00};
  20. static unsigned char crossmask_bits[] = {
  21.     0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xd0, 0x05,
  22.     0xbf, 0x7e, 0x7f, 0x7f, 0xbf, 0x7e, 0xd0, 0x05, 0xe0, 0x03, 0xc0, 0x01,
  23. 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0x00, 0x00};
  24.  
  25. static void
  26. checkGeometry(name, x, y, width, height)
  27.     char   *name;
  28.     int    *x, *y, *width, *height;
  29. /* fixed so that it handles negative positions 12/21/93          */
  30. /* note that this is NOT standard X syntax, but it was requested */
  31. /* and it's how BRM-Hadley works.                       [BDyess] */
  32. {
  33.     char   *adefault;
  34.     char    buf[100];
  35.     char   *s;
  36.  
  37. #ifdef RJC
  38.     *x = *y = INVALID_POSITION;
  39. #endif                /* RJC */
  40.  
  41.     sprintf(buf, "%s.geometry", name);
  42.     adefault = NULL; /*stringDefault(buf,NULL);*/
  43.     if (adefault == NULL)
  44.     return;
  45.     /* geometry should be of the form 502x885+1+1, 502x885, or +1+1 */
  46.     s = adefault;
  47.     if (*s != '+' && *s != '-') {
  48.     while (*s != 'x' && *s != 0)
  49.         s++;
  50.     *width = atoi(adefault);
  51.     if (*s == 0)
  52.         return;
  53.     s++;
  54.     adefault = s;
  55.     while (*s != '+' && *s != '-' && *s != 0)
  56.         s++;
  57.     *height = atoi(adefault);
  58.     if (*s == 0)
  59.         return;
  60.     }
  61.     adefault = s;
  62.     s++;
  63.     if (*s == '-')
  64.     s++;            /* for the case where they have wxh+-x+y */
  65.     while (*s != '+' && *s != '-' && *s != 0)
  66.     s++;
  67.     *x = atoi(adefault + 1);
  68.     if (*adefault == '-')
  69.     *x = -*x;
  70.     if (*s == 0)
  71.     return;
  72.     *y = atoi(s + 1);
  73.     if (*s == '-')
  74.     *y = -*y;
  75.     /* printf("width: %d, height: %d, x: %d, y: %d\n",*width, *height,*x,*y); */
  76.     return;
  77. }
  78.  
  79. static  void
  80. checkParent(name, parent)
  81.     char   *name;
  82.     W_Window *parent;
  83. {
  84.     char   *adefault;
  85.     char    buf[100];
  86.     int     i;
  87.     struct windowlist *windows;
  88.  
  89.     sprintf(buf, "%s.parent", name);
  90.     adefault = NULL; /*stringDefault(buf,NULL);*/
  91.     if (adefault == NULL)
  92.     return;
  93.     /* parent must be name of other window or "root" */
  94.     if (strcasecmp(adefault, "root") == 0) {
  95.     *parent = W_Window2Void(&myroot);
  96.     return;
  97.     }
  98.     for (i = 0; i < HASHSIZE; i++) {
  99.     windows = hashtable[i];
  100.     while (windows != NULL) {
  101.         if (strcasecmp(adefault, windows->window->name) == 0) {
  102.         *parent = W_Window2Void(windows->window);
  103.         return;
  104.         }
  105.         windows = windows->next;
  106.     }
  107.     }
  108. }
  109.  
  110. static void
  111. checkCursor(name, cursname, cursor)
  112.     char   *name;
  113.     char   *cursname;
  114.     Cursor *cursor;
  115. {
  116.     char    buf[100];
  117.     char   *adefault;
  118.  
  119.     *cursor = 0;
  120.  
  121.     sprintf(buf, "%s.cursor", name);
  122.     adefault = cursname; /*stringDefault(buf,cursname);*/
  123.  
  124.     if (adefault == NULL)
  125.     return;
  126.  
  127. #ifdef RFCURSORS
  128.     cnum = XmuCursorNameToIndex(adefault);
  129.     if (cnum != -1) {
  130.     XColor  f, b;
  131.     *cursor = XCreateFontCursor(W_Display, cnum);
  132.     if (cnum == XC_xterm) {
  133.  
  134.         f.pixel = colortable[W_Yellow].pixelValue;
  135.         b.pixel = colortable[W_Black].pixelValue;
  136.  
  137.         XQueryColor(W_Display, W_Colormap, &f);
  138.         XQueryColor(W_Display, W_Colormap, &b);
  139.  
  140.         XRecolorCursor(W_Display, *cursor, &f, &b);
  141.     } else if (cnum == XC_pirate) {
  142.         f.pixel = colortable[W_Red].pixelValue;
  143.         b.pixel = colortable[W_Black].pixelValue;
  144.  
  145.         XQueryColor(W_Display, W_Colormap, &f);
  146.         XQueryColor(W_Display, W_Colormap, &b);
  147.  
  148.         XRecolorCursor(W_Display, *cursor, &f, &b);
  149.     }
  150.     } else
  151. #endif
  152.     if (0 == strcmp("bomb here", adefault)) {
  153.     static Cursor bomb_here = 0;
  154.     if (bomb_here == 0) {
  155.         bomb_here = make_cursor(cross_bits, crossmask_bits,
  156.                     cross_width, cross_height,
  157.                     cross_x_hot, cross_y_hot);
  158.     }
  159.     *cursor = bomb_here;
  160.     } else if (0 == strcmp("tiny", adefault)) {
  161.     static Cursor tiny = 0;
  162.     if(tiny == 0) {
  163.         tiny = make_cursor(tiny_bits, tinymask_bits,
  164.                    tiny_width, tiny_height,
  165.                    tiny_x_hot, tiny_y_hot);
  166.     }
  167.     *cursor = tiny;
  168.     }
  169. }
  170.  
  171. static int
  172. checkMapped(name)
  173.     char   *name;
  174. {
  175.     char    buf[100];
  176.  
  177.     sprintf(buf, "%s.mapped", name);
  178.     return 0;
  179. }
  180.  
  181. #ifdef BUFFERING
  182. static int
  183. checkBuffered(name)
  184.     char *name;
  185. {
  186.     char    buf[100];
  187.  
  188.     sprintf(buf, "%s.buffered", name);
  189. #if 0
  190.     /* defaults to on when in xpm mode for local window [BDyess] */
  191.     /* don't turn it on unless asked when in OR mode [BDyess] */
  192.     if(xpm && !useOR && strcmp(name,"local") == 0) {
  193.       printf("Double Buffering automatically enabled.  Use -O if your machine can't handle it.\n");
  194.       return (booleanDefault(buf, 1));
  195.     } else {
  196.       return (booleanDefault(buf, 0));
  197.     }
  198. #else
  199.     return useBuffered;
  200. #endif /*0*/
  201. }
  202. #endif /*BUFFERING [BDyess]*/
  203.  
  204. static void
  205. addToHash(win)
  206.     struct window *win;
  207. {
  208.     struct windowlist **new;
  209.  
  210. #ifdef DEBUG
  211.     printf("Adding to %d\n", hash(win->window));
  212. #endif
  213.     new = &hashtable[hash(win->window)];
  214.     while (*new != NULL) {
  215.     new = &((*new)->next);
  216.     }
  217.     *new = (struct windowlist *) malloc(sizeof(struct windowlist));
  218.     (*new)->next = NULL;
  219.     (*new)->window = win;
  220. }
  221.  
  222. struct window *
  223. newWindow(window, type)
  224.     Window  window;
  225.     int     type;
  226. {
  227.     struct window *neww;
  228.  
  229.     neww = (struct window *) malloc(sizeof(struct window));
  230.     neww->window = window;
  231.     neww->drawable = window;
  232. #ifdef BUFFERING
  233.     neww->isbuffered = 0;
  234.     neww->buffer = 0;
  235. #endif /*BUFFERING [BDyess]*/
  236.     neww->type = type;
  237.     neww->mapped = 0;
  238.     neww->insensitive = 0;
  239.     addToHash(neww);
  240.     return (neww);
  241. }
  242.  
  243. void
  244. W_RenameWindow(window, str)
  245.     W_Window window;
  246.     char   *str;
  247. {
  248.     XStoreName(W_Display, ((struct window *) window)->window, str);
  249. }
  250.  
  251.   W_Window
  252. w_MakeWindow(name, x, y, width, height, parent,
  253.          cursname, border, color, wsort)
  254.     char   *name;
  255.     int     x, y, width, height;
  256.     W_Window parent;
  257.     char   *cursname;
  258.     int     border;
  259.     W_Color color;        /* unused */
  260.     int     wsort;        /* WIN_? */
  261. {
  262.     int     gx, gy;
  263.     struct window *neww;
  264.     Window  wparent;
  265.     W_Window borderwin = 0;
  266.     Cursor  cursor;
  267.     XSetWindowAttributes attrs;
  268.     unsigned int pwidth, pheight;    /* pixel width and height */
  269.  
  270.     if(wsort != WIN_BORDER) {
  271.       checkGeometry(name, &gx, &gy, &width, &height);
  272.       if (gx != INVALID_POSITION)
  273.       x = gx;
  274.       if (gy != INVALID_POSITION)
  275.       y = gy;
  276.  
  277.       checkParent(name, &parent);
  278.  
  279.       if (wsort == WIN_TEXT || wsort == WIN_SCROLL || wsort == WIN_MENU) {
  280.       pwidth = width * W_Textwidth + WIN_EDGE * 2;
  281.       if (wsort == WIN_MENU)
  282.           pheight = height * (W_Textheight + MENU_PAD * 2 + MENU_BAR) - MENU_BAR;
  283.       else
  284.           pheight = height * W_Textheight + MENU_PAD * 2;
  285.       } else {
  286.       pwidth = width;
  287.       pheight = height;
  288.       }
  289.  
  290.       /* if this isn't a border, create one with another call to this 
  291.      function [BDyess] */
  292.       if (border) {
  293. #if 0
  294.     char *newname = (char*) malloc (strlen(name) + 8);
  295.  
  296.     strcpy(newname,name);
  297.     strcat(newname,"_border");
  298.     free(newname);
  299. #endif /*0*/
  300.     parent = w_MakeWindow(name, x, y, pwidth+border*2, pheight+border*2, 
  301.                   parent, cursname, border, color, WIN_BORDER);
  302.     borderwin = parent;
  303.     /* update the parameters to reflect the size of the surrounding burder
  304.        [BDyess] */
  305.     x = border;
  306.     y = border;
  307.       }
  308.       attrs.background_pixel = colortable[W_Black].pixelValue;
  309.     } else { /* it is a border, set the background [BDyess] */
  310.       pwidth = width;
  311.       pheight = height;
  312.       attrs.background_pixel = colortable[DARK_GREY].pixelValue;
  313.     }
  314.  
  315.     wparent = W_Void2Window(parent)->window;
  316.  
  317.     checkCursor(name, cursname, &cursor);
  318.     attrs.cursor = cursor;
  319.  
  320.     switch (wsort) {
  321.     case WIN_TEXT:
  322.     case WIN_MENU:
  323.     attrs.event_mask = KeyPressMask | ButtonPressMask | ExposureMask | ButtonReleaseMask;
  324.     attrs.do_not_propagate_mask = ExposureMask | KeyPressMask | ButtonPressMask;
  325.     break;
  326.     case WIN_GRAPH:
  327.     attrs.event_mask = KeyPressMask | ButtonPressMask | ExposureMask | LeaveWindowMask | ButtonReleaseMask | ButtonMotionMask;
  328.     attrs.do_not_propagate_mask = ExposureMask;
  329.     break;
  330.     case WIN_SCROLL:
  331.     attrs.event_mask = ResizeRedirectMask | ExposureMask | KeyPressMask | ButtonReleaseMask | ButtonPressMask;
  332.     attrs.do_not_propagate_mask = ResizeRedirectMask | ExposureMask;
  333.     break;
  334.     case WIN_BORDER:
  335.         attrs.event_mask = ExposureMask;
  336.     attrs.do_not_propagate_mask = ExposureMask;
  337.     break;
  338.     default:
  339.     fprintf(stderr, "x11window.c: w_MakeWindow: unknown wsort %d\n", wsort);
  340.     }
  341.  
  342. #ifdef AUTOKEY
  343.     if (attrs.event_mask & KeyPressMask)
  344.     attrs.event_mask |= KeyReleaseMask;
  345. #endif                /* AUTOKEY */
  346.  
  347.     if (strcmp(name, "xgalaga_icon") == 0)    /* icon should not select for
  348.                            input */
  349.     attrs.event_mask = ExposureMask;
  350.     if (strcmp(name, "wait_icon") == 0)    /* same here [BDyess] */
  351.     attrs.event_mask = ExposureMask;
  352.  
  353.     if (strcmp(name, "info") == 0)    /* make info window passthru [BDyess] */
  354.     attrs.event_mask = ExposureMask;
  355.  
  356.     neww = newWindow
  357.     (XCreateWindow(W_Display, wparent, x, y, pwidth, pheight,
  358.               (unsigned) 0,
  359.                CopyFromParent, InputOutput, CopyFromParent,
  360.                (unsigned)(CWBackPixel | CWEventMask |
  361.                (cursor ? CWCursor : 0)),
  362.                &attrs),
  363.      wsort);
  364.  
  365.     neww->cursor = cursor;
  366.     /* keep track of each windows border so they can be mapped and unmapped
  367.        together. [BDyess] */
  368.     neww->borderwin = borderwin;
  369.     neww->border = border;
  370.     neww->border_color = NONE;
  371.  
  372.     {
  373.     char   *s;
  374.  
  375.     s = name;
  376.  
  377.     XStoreName(W_Display, neww->window, s);
  378.     }
  379.  
  380.     wm_size_hint.width = wm_size_hint.min_width =
  381.     wm_size_hint.max_width = wm_size_hint.base_width = pwidth;
  382.     wm_size_hint.min_height = wm_size_hint.height =
  383.     wm_size_hint.max_height = wm_size_hint.base_height = pheight;
  384.     wm_size_hint.flags = USSize | PMinSize | PMaxSize | PBaseSize;
  385.     if (gx > INVALID_POSITION || gy > INVALID_POSITION) {
  386.     wm_size_hint.flags |= USPosition;
  387.     wm_size_hint.x = x;
  388.     wm_size_hint.y = y;
  389.     }
  390.     XSetWMNormalHints(W_Display, neww->window, &wm_size_hint);
  391.  
  392.     class_hint.res_name = name;
  393.     class_hint.res_class = "XGalaga";
  394.     XSetClassHint(W_Display, neww->window, &class_hint);
  395.  
  396.     XSetWMHints(W_Display, neww->window, &wm_hint);
  397.  
  398.     if (((wparent == W_Root &&
  399.       baseWin != NULL &&
  400.       strcmp(name, "wait") != 0)
  401.      || wsort == WIN_MENU) &&
  402.     strcmp(name, "MetaServer List") != 0 &&
  403.     strcmp(name, "Motd") != 0) {
  404.     XSetTransientForHint(W_Display, neww->window,
  405.                  W_Void2Window(baseWin)->window);
  406.     }
  407.     neww->name = strdup(name);
  408.     neww->width = width;
  409.     neww->height = height;
  410.     if (wsort == WIN_MENU) {
  411.     int     i;
  412.     struct menuItem *items;
  413.     items = (struct menuItem *) malloc(height * sizeof(struct menuItem));
  414.     for (i = 0; i < height; i++) {
  415.         items[i].string = NULL;
  416.         items[i].color = W_White;
  417.         items[i].font = W_RegularFont;
  418.     }
  419.     neww->data = (char *) items;
  420.     } else {
  421.     neww->data = 0;
  422.     }
  423.  
  424.     if (wparent != W_Root && wsort != WIN_BORDER)
  425.     if (checkMapped(name))
  426.         W_MapWindow(W_Window2Void(neww));
  427.  
  428. #ifdef BUFFERING
  429.     /* turn on buffering if name.buffered: on [BDyess] */
  430.     if(wsort != WIN_BORDER) {
  431.       if(checkBuffered(name)) {
  432.     W_Buffer(W_Window2Void(neww), 1);
  433.       }
  434.     }
  435. #endif /*BUFFERING [BDyess]*/
  436.  
  437. #ifdef DEBUG
  438.     printf("New graphics window %d, child of %d\n", neww, parent);
  439. #endif
  440.  
  441. #ifdef FOURPLANEFIX
  442.     XSetWindowColormap(W_Display, neww->window, W_Colormap);
  443. #endif
  444.  
  445.     return (W_Window2Void(neww));
  446. }
  447.  
  448. W_Window
  449. W_MakeWindow(name, x, y, width, height, parent, cursname, border, color)
  450.     char   *name;
  451.     int     x, y, width, height;
  452.     W_Window parent;
  453.     char   *cursname;
  454.     int     border;
  455.     W_Color color;
  456. {
  457.     return w_MakeWindow(name, x, y, width, height, parent,
  458.             cursname, border, color, WIN_GRAPH);
  459. }
  460.  
  461. W_Window
  462. W_MakeTextWindow(name, x, y, width, height, parent, cursname, border)
  463.     char   *name;
  464.     int     x, y, width, height;
  465.     W_Window parent;
  466.     char   *cursname;
  467.     int     border;
  468. {
  469.     return w_MakeWindow(name, x, y, width, height,
  470.             parent, cursname, border, W_White, WIN_TEXT);
  471. }
  472.  
  473.  
  474.  
  475. W_Window
  476. W_MakeScrollingWindow(name, x, y, width, height, parent, cursname, border)
  477.     char   *name;
  478.     int     x, y, width, height;
  479.     W_Window parent;
  480.     char   *cursname;
  481.     int     border;
  482. {
  483.     return w_MakeWindow(name, x, y, width, height, parent, cursname,
  484.             border, W_White, WIN_SCROLL);
  485. }
  486.  
  487. void
  488. W_SetIconWindow(win, icon)
  489.     W_Window win;
  490.     W_Window icon;
  491. {
  492.     XWMHints hints;
  493.  
  494.     XSetIconName(W_Display, W_Void2Window(icon)->window, W_Void2Window(win)->name);
  495.  
  496.     hints.flags = IconWindowHint;
  497.     hints.icon_window = W_Void2Window(icon)->window;
  498.     XSetWMHints(W_Display, W_Void2Window(win)->window, &hints);
  499. }
  500.  
  501.  
  502.  
  503.